ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಲು ಪ್ರಾಯೋಗಿಕ ಮಾರ್ಗದರ್ಶಿ, ಆಧುನೀಕರಣ ಮತ್ತು ನಿರ್ವಹಣೆಗಾಗಿ ಗುರುತಿಸುವಿಕೆ, ಆದ್ಯತೆ, ತಂತ್ರಗಳು, ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ಪಳಗಿಸುವುದು: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ತಂತ್ರಗಳು
ಲೆಗಸಿ ಕೋಡ್. ಈ ಪದವೇ ಆಗಾಗ್ಗೆ ವಿಸ್ತಾರವಾದ, ದಾಖಲೆಗಳಿಲ್ಲದ ಸಿಸ್ಟಮ್‌ಗಳು, ದುರ್ಬಲ ಅವಲಂಬನೆಗಳು ಮತ್ತು ಅಗಾಧವಾದ ಭಯದ ಭಾವನೆಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಜಗತ್ತಿನಾದ್ಯಂತ ಅನೇಕ ಡೆವಲಪರ್‌ಗಳು ಈ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮತ್ತು ವಿಕಸನಗೊಳಿಸುವ ಸವಾಲನ್ನು ಎದುರಿಸುತ್ತಾರೆ, ಇವುಗಳು ಸಾಮಾನ್ಯವಾಗಿ ವ್ಯವಹಾರ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ನಿರ್ಣಾಯಕವಾಗಿರುತ್ತವೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಲು ಪ್ರಾಯೋಗಿಕ ತಂತ್ರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ನಿರಾಶೆಯ ಮೂಲವನ್ನು ಆಧುನೀಕರಣ ಮತ್ತು ಸುಧಾರಣೆಯ ಅವಕಾಶವನ್ನಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
ಲೆಗಸಿ ಕೋಡ್ ಎಂದರೇನು?
ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ತಂತ್ರಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು, "ಲೆಗಸಿ ಕೋಡ್" ಎಂದರೆ ಏನೆಂದು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಅತ್ಯಗತ್ಯ. ಈ ಪದವು ಸರಳವಾಗಿ ಹಳೆಯ ಕೋಡ್ ಅನ್ನು ಸೂಚಿಸಬಹುದಾದರೂ, ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮವಾದ ವ್ಯಾಖ್ಯಾನವು ಅದರ ನಿರ್ವಹಣೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ. ಮೈಕೆಲ್ ಫೆದರ್ಸ್, ಅವರ "ವರ್ಕಿಂಗ್ ಎಫೆಕ್ಟಿವ್ಲಿ ವಿತ್ ಲೆಗಸಿ ಕೋಡ್," ಎಂಬ ಶ್ರೇಷ್ಠ ಪುಸ್ತಕದಲ್ಲಿ, ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ಟೆಸ್ಟ್‌ಗಳಿಲ್ಲದ ಕೋಡ್ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತಾರೆ. ಈ ಟೆಸ್ಟ್‌ಗಳ ಕೊರತೆಯು ರಿಗ್ರೆಷನ್‌ಗಳನ್ನು ಪರಿಚಯಿಸದೆ ಕೋಡ್ ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಮಾರ್ಪಡಿಸುವುದನ್ನು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಲೆಗಸಿ ಕೋಡ್ ಇತರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸಹ ಪ್ರದರ್ಶಿಸಬಹುದು:
- ದಾಖಲಾತಿಗಳ ಕೊರತೆ: ಮೂಲ ಡೆವಲಪರ್‌ಗಳು ಹೊರಟುಹೋಗಿರಬಹುದು, ಸಿಸ್ಟಮ್‌ನ ಆರ್ಕಿಟೆಕ್ಚರ್, ವಿನ್ಯಾಸದ ನಿರ್ಧಾರಗಳು ಅಥವಾ ಮೂಲಭೂತ ಕಾರ್ಯಚಟುವಟಿಕೆಗಳನ್ನು ವಿವರಿಸುವ ಕಡಿಮೆ ಅಥವಾ ಯಾವುದೇ ದಾಖಲೆಗಳನ್ನು ಬಿಟ್ಟು ಹೋಗಿರಬಹುದು.
- ಸಂಕೀರ್ಣ ಅವಲಂಬನೆಗಳು: ಕೋಡ್ ಬಿಗಿಯಾಗಿ ಕಪಲ್ ಆಗಿರಬಹುದು, ಇದು ಸಿಸ್ಟಮ್‌ನ ಇತರ ಭಾಗಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರದೆ ಪ್ರತ್ಯೇಕ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಮತ್ತು ಮಾರ್ಪಡಿಸಲು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ.
- ಹಳೆಯ ತಂತ್ರಜ್ಞಾನಗಳು: ಕೋಡ್ ಹಳೆಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು, ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಅಥವಾ ಇನ್ನು ಮುಂದೆ ಸಕ್ರಿಯವಾಗಿ ಬೆಂಬಲಿಸದ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿ ಬರೆಯಲ್ಪಟ್ಟಿರಬಹುದು, ಇದು ಭದ್ರತಾ ಅಪಾಯಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ ಮತ್ತು ಆಧುನಿಕ ಉಪಕರಣಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಸೀಮಿತಗೊಳಿಸುತ್ತದೆ.
- ಕಳಪೆ ಕೋಡ್ ಗುಣಮಟ್ಟ: ಕೋಡ್ ನಕಲಿ ಕೋಡ್, ದೀರ್ಘ ಮೆಥಡ್‌ಗಳು ಮತ್ತು ಇತರ ಕೋಡ್ ಸ್ಮೆಲ್‌ಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಇದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ.
- ದುರ್ಬಲ ವಿನ್ಯಾಸ: ಸಣ್ಣ ಬದಲಾವಣೆಗಳು ಸಹ ಅನಿರೀಕ್ಷಿತ ಮತ್ತು ವ್ಯಾಪಕ ಪರಿಣಾಮಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು.
ಲೆಗಸಿ ಕೋಡ್ ಸ್ವಾಭಾವಿಕವಾಗಿ ಕೆಟ್ಟದ್ದಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯ. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಮಹತ್ವದ ಹೂಡಿಕೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಮೌಲ್ಯಯುತವಾದ ಡೊಮೇನ್ ಜ್ಞಾನವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ನ ಗುರಿಯು ಈ ಮೌಲ್ಯವನ್ನು ಸಂರಕ್ಷಿಸುವುದು ಮತ್ತು ಕೋಡ್‌ನ ನಿರ್ವಹಣೆ, ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುವುದಾಗಿದೆ.
ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ಏಕೆ ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಬೇಕು?
ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡುವುದು ಒಂದು ದೊಡ್ಡ ಕಾರ್ಯವಾಗಿರಬಹುದು, ಆದರೆ ಪ್ರಯೋಜನಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸವಾಲುಗಳನ್ನು ಮೀರಿಸುತ್ತವೆ. ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ನಲ್ಲಿ ಹೂಡಿಕೆ ಮಾಡಲು ಕೆಲವು ಪ್ರಮುಖ ಕಾರಣಗಳು ಇಲ್ಲಿವೆ:
- ಸುಧಾರಿತ ನಿರ್ವಹಣೆ: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ, ನಿರಂತರ ನಿರ್ವಹಣೆಗೆ ಬೇಕಾದ ವೆಚ್ಚ ಮತ್ತು ಪ್ರಯತ್ನವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಜಾಗತಿಕ ತಂಡಗಳಿಗೆ, ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ನಿರ್ದಿಷ್ಟ ವ್ಯಕ್ತಿಗಳ ಮೇಲಿನ ಅವಲಂಬನೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಜ್ಞಾನ ಹಂಚಿಕೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ.
- ತಾಂತ್ರಿಕ ಸಾಲವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು: ತಾಂತ್ರಿಕ ಸಾಲವು ದೀರ್ಘಾವಧಿಯ ಉತ್ತಮ ವಿಧಾನವನ್ನು ಬಳಸುವ ಬದಲು ಈಗ ಸುಲಭವಾದ ಪರಿಹಾರವನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದರಿಂದ ಉಂಟಾಗುವ ಪುನರ್ನಿರ್ಮಾಣದ ಸೂಚಿತ ವೆಚ್ಚವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಈ ಸಾಲವನ್ನು ತೀರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಕೋಡ್‌ಬೇಸ್‌ನ ಒಟ್ಟಾರೆ ಆರೋಗ್ಯವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
- ಹೆಚ್ಚಿದ ವಿಶ್ವಾಸಾರ್ಹತೆ: ಕೋಡ್ ಸ್ಮೆಲ್‌ಗಳನ್ನು ಪರಿಹರಿಸುವ ಮೂಲಕ ಮತ್ತು ಕೋಡ್‌ನ ರಚನೆಯನ್ನು ಸುಧಾರಿಸುವ ಮೂಲಕ, ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಬಗ್‌ಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸಿಸ್ಟಮ್‌ನ ಒಟ್ಟಾರೆ ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
- ಹೆಚ್ಚಿದ ಕಾರ್ಯಕ್ಷಮತೆ: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಿ ಪರಿಹರಿಸಬಹುದು, ಇದರಿಂದಾಗಿ ವೇಗವಾದ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯಗಳು ಮತ್ತು ಸುಧಾರಿತ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕತೆ ಉಂಟಾಗುತ್ತದೆ.
- ಸುಲಭವಾದ ಏಕೀಕರಣ: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಲೆಗಸಿ ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೊಸ ಸಿಸ್ಟಮ್‌ಗಳು ಮತ್ತು ತಂತ್ರಜ್ಞಾನಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ, ಇದು ನಾವೀನ್ಯತೆ ಮತ್ತು ಆಧುನೀಕರಣವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಯುರೋಪಿಯನ್ ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗೆ ಬೇರೆ API ಬಳಸುವ ಹೊಸ ಪೇಮೆಂಟ್ ಗೇಟ್‌ವೇಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಬೇಕಾಗಬಹುದು.
- ಸುಧಾರಿತ ಡೆವಲಪರ್ ಮನೋಬಲ: ಸ್ವಚ್ಛ, ಉತ್ತಮ-ರಚನಾತ್ಮಕ ಕೋಡ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ಆನಂದದಾಯಕ ಮತ್ತು ಉತ್ಪಾದಕವಾಗಿರುತ್ತದೆ. ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಮನೋಬಲವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಭೆಗಳನ್ನು ಆಕರ್ಷಿಸುತ್ತದೆ.
ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅಭ್ಯರ್ಥಿಗಳನ್ನು ಗುರುತಿಸುವುದು
ಎಲ್ಲಾ ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಬೇಕಾಗಿಲ್ಲ. ಈ ಕೆಳಗಿನ ಅಂಶಗಳ ಆಧಾರದ ಮೇಲೆ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಪ್ರಯತ್ನಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡುವುದು ಮುಖ್ಯ:
- ಬದಲಾವಣೆಯ ಆವರ್ತನ: ಆಗಾಗ್ಗೆ ಮಾರ್ಪಡಿಸಲಾದ ಕೋಡ್ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ಗೆ ಪ್ರಮುಖ ಅಭ್ಯರ್ಥಿಯಾಗಿದೆ, ಏಕೆಂದರೆ ನಿರ್ವಹಣೆಯಲ್ಲಿನ ಸುಧಾರಣೆಗಳು ಅಭಿವೃದ್ಧಿ ಉತ್ಪಾದಕತೆಯ ಮೇಲೆ ಮಹತ್ವದ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ.
- ಸಂಕೀರ್ಣತೆ: ಸಂಕೀರ್ಣ ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟಕರವಾದ ಕೋಡ್ ಬಗ್‌ಗಳನ್ನು ಹೊಂದುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚು ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿ ಮಾರ್ಪಡಿಸಲು ಕಷ್ಟ.
- ಬಗ್‌ಗಳ ಪರಿಣಾಮ: ವ್ಯವಹಾರ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ನಿರ್ಣಾಯಕವಾದ ಅಥವಾ ದುಬಾರಿ ದೋಷಗಳನ್ನು ಉಂಟುಮಾಡುವ ಹೆಚ್ಚಿನ ಅಪಾಯವಿರುವ ಕೋಡ್‌ಗೆ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ಗೆ ಆದ್ಯತೆ ನೀಡಬೇಕು.
- ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳು: ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆ ಎಂದು ಗುರುತಿಸಲಾದ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಬೇಕು.
- ಕೋಡ್ ಸ್ಮೆಲ್‌ಗಳು: ದೀರ್ಘ ಮೆಥಡ್‌ಗಳು, ದೊಡ್ಡ ಕ್ಲಾಸ್‌ಗಳು, ನಕಲಿ ಕೋಡ್ ಮತ್ತು ಫೀಚರ್ ಎನ್ವಿಯಂತಹ ಸಾಮಾನ್ಯ ಕೋಡ್ ಸ್ಮೆಲ್‌ಗಳಿಗಾಗಿ ಗಮನವಿಡಿ. ಇವುಗಳು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ನಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಬಹುದಾದ ಪ್ರದೇಶಗಳ ಸೂಚಕಗಳಾಗಿವೆ.
ಉದಾಹರಣೆ: ಜಾಗತಿಕ ಲಾಜಿಸ್ಟಿಕ್ಸ್ ಕಂಪನಿಯೊಂದು ಸಾಗಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಲೆಗಸಿ ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೊಂದಿದೆ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಶಿಪ್ಪಿಂಗ್ ವೆಚ್ಚಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬದಲಾಗುತ್ತಿರುವ ನಿಯಮಗಳು ಮತ್ತು ಇಂಧನ ಬೆಲೆಗಳಿಂದಾಗಿ ಆಗಾಗ್ಗೆ ನವೀಕರಿಸಲಾಗುತ್ತದೆ. ಈ ಮಾಡ್ಯೂಲ್ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ಗೆ ಪ್ರಮುಖ ಅಭ್ಯರ್ಥಿಯಾಗಿದೆ.
ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ತಂತ್ರಗಳು
ಹಲವಾರು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ತಂತ್ರಗಳು ಲಭ್ಯವಿವೆ, ಪ್ರತಿಯೊಂದೂ ನಿರ್ದಿಷ್ಟ ಕೋಡ್ ಸ್ಮೆಲ್‌ಗಳನ್ನು ಪರಿಹರಿಸಲು ಅಥವಾ ಕೋಡ್‌ನ ನಿರ್ದಿಷ್ಟ ಅಂಶಗಳನ್ನು ಸುಧಾರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಕೆಲವು ತಂತ್ರಗಳು ಇಲ್ಲಿವೆ:
ಮೆಥಡ್‌ಗಳನ್ನು ರಚಿಸುವುದು (Composing Methods)
ಈ ತಂತ್ರಗಳು ದೊಡ್ಡ, ಸಂಕೀರ್ಣ ಮೆಥಡ್‌ಗಳನ್ನು ಚಿಕ್ಕದಾದ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಮೆಥಡ್‌ಗಳಾಗಿ ವಿಭಜಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತವೆ. ಇದು ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ನಕಲನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
- Extract Method: ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುವ ಕೋಡ್‌ನ ಬ್ಲಾಕ್ ಅನ್ನು ಗುರುತಿಸಿ ಅದನ್ನು ಹೊಸ ಮೆಥಡ್‌ಗೆ ಸರಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Inline Method: ಇದು ಮೆಥಡ್ ಕರೆಯನ್ನು ಮೆಥಡ್‌ನ ಬಾಡಿಯೊಂದಿಗೆ ಬದಲಾಯಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಮೆಥಡ್‌ನ ಹೆಸರು ಅದರ ಬಾಡಿಯಷ್ಟೇ ಸ್ಪಷ್ಟವಾಗಿದ್ದಾಗ ಅಥವಾ ನೀವು Extract Method ಅನ್ನು ಬಳಸಲು ಹೊರಟಾಗ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮೆಥಡ್ ತುಂಬಾ ಚಿಕ್ಕದಾಗಿದ್ದಾಗ ಇದನ್ನು ಬಳಸಿ.
- Replace Temp with Query: ಇದು ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್ ಅನ್ನು ಬೇಡಿಕೆಯ ಮೇರೆಗೆ ವೇರಿಯಬಲ್‌ನ ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಮೆಥಡ್ ಕರೆಯೊಂದಿಗೆ ಬದಲಾಯಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Introduce Explaining Variable: ಒಂದು ಅಭಿವ್ಯಕ್ತಿಯ ಫಲಿತಾಂಶವನ್ನು ವಿವರಣಾತ್ಮಕ ಹೆಸರಿನೊಂದಿಗೆ ವೇರಿಯಬಲ್‌ಗೆ ನಿಯೋಜಿಸಲು ಇದನ್ನು ಬಳಸಿ, ಅದರ ಉದ್ದೇಶವನ್ನು ಸ್ಪಷ್ಟಪಡಿಸುತ್ತದೆ.
ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ನಡುವೆ ಫೀಚರ್‌ಗಳನ್ನು ಸರಿಸುವುದು (Moving Features Between Objects)
ಈ ತಂತ್ರಗಳು ಜವಾಬ್ದಾರಿಗಳನ್ನು ಅವು ಸೇರಿರುವ ಸ್ಥಳಕ್ಕೆ ಸರಿಸುವ ಮೂಲಕ ಕ್ಲಾಸ್‌ಗಳು ಮತ್ತು ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ವಿನ್ಯಾಸವನ್ನು ಸುಧಾರಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತವೆ.
- Move Method: ಇದು ಒಂದು ಮೆಥಡ್ ಅನ್ನು ಒಂದು ಕ್ಲಾಸ್‌ನಿಂದ ತಾರ್ಕಿಕವಾಗಿ ಸೇರಿರುವ ಇನ್ನೊಂದು ಕ್ಲಾಸ್‌ಗೆ ಸರಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Move Field: ಇದು ಒಂದು ಫೀಲ್ಡ್ ಅನ್ನು ಒಂದು ಕ್ಲಾಸ್‌ನಿಂದ ತಾರ್ಕಿಕವಾಗಿ ಸೇರಿರುವ ಇನ್ನೊಂದು ಕ್ಲಾಸ್‌ಗೆ ಸರಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Extract Class: ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕ್ಲಾಸ್‌ನಿಂದ ಹೊರತೆಗೆಯಲಾದ ಜವಾಬ್ದಾರಿಗಳ ಒಂದು ಸುಸಂಬದ್ಧ ಗುಂಪಿನಿಂದ ಹೊಸ ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Inline Class: ಒಂದು ಕ್ಲಾಸ್ ತನ್ನ ಅಸ್ತಿತ್ವವನ್ನು ಸಮರ್ಥಿಸಿಕೊಳ್ಳಲು ಸಾಕಷ್ಟು ಕೆಲಸ ಮಾಡದಿದ್ದಾಗ ಅದನ್ನು ಇನ್ನೊಂದರಲ್ಲಿ ವಿಲೀನಗೊಳಿಸಲು ಇದನ್ನು ಬಳಸಿ.
- Hide Delegate: ಇದು ಕ್ಲೈಂಟ್ ಮತ್ತು ಡೆಲಿಗೇಟ್ ನಡುವಿನ ಕಪ್ಲಿಂಗ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ಕ್ಲೈಂಟ್‌ನಿಂದ ಡೆಲಿಗೇಶನ್ ಲಾಜಿಕ್ ಅನ್ನು ಮರೆಮಾಡಲು ಸರ್ವರ್‌ನಲ್ಲಿ ಮೆಥಡ್‌ಗಳನ್ನು ರಚಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Remove Middle Man: ಒಂದು ಕ್ಲಾಸ್ ತನ್ನ ಬಹುತೇಕ ಎಲ್ಲಾ ಕೆಲಸವನ್ನು ಡೆಲಿಗೇಟ್ ಮಾಡುತ್ತಿದ್ದರೆ, ಇದು ಮಧ್ಯವರ್ತಿಯನ್ನು ತೆಗೆದುಹಾಕಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
- Introduce Foreign Method: ಸರ್ವರ್ ಕ್ಲಾಸ್‌ನಿಂದ ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿರುವ ಆದರೆ ಪ್ರವೇಶದ ಕೊರತೆ ಅಥವಾ ಸರ್ವರ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಯೋಜಿತ ಬದಲಾವಣೆಗಳಿಂದಾಗಿ ಮಾರ್ಪಡಿಸಲಾಗದ ಫೀಚರ್‌ಗಳೊಂದಿಗೆ ಕ್ಲೈಂಟ್‌ಗೆ ಸೇವೆ ಸಲ್ಲಿಸಲು ಕ್ಲೈಂಟ್ ಕ್ಲಾಸ್‌ಗೆ ಮೆಥಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.
- Introduce Local Extension: ಹೊಸ ಮೆಥಡ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಹೊಸ ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ನೀವು ಕ್ಲಾಸ್‌ನ ಮೂಲವನ್ನು ನಿಯಂತ್ರಿಸದಿದ್ದಾಗ ಮತ್ತು ನೇರವಾಗಿ ನಡವಳಿಕೆಯನ್ನು ಸೇರಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದಾಗ ಉಪಯುಕ್ತ.
ಡೇಟಾವನ್ನು ಸಂಘಟಿಸುವುದು (Organizing Data)
ಈ ತಂತ್ರಗಳು ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ಮತ್ತು ಪ್ರವೇಶಿಸುವ ವಿಧಾನವನ್ನು ಸುಧಾರಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತವೆ, ಅದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಮಾರ್ಪಡಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
- Replace Data Value with Object: ಇದು ಸರಳ ಡೇಟಾ ಮೌಲ್ಯವನ್ನು ಸಂಬಂಧಿತ ಡೇಟಾ ಮತ್ತು ನಡವಳಿಕೆಯನ್ನು ಒಳಗೊಂಡಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Change Value to Reference: ಇದು ಮೌಲ್ಯದ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರೆಫರೆನ್ಸ್ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಬದಲಾಯಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಅನೇಕ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಒಂದೇ ಮೌಲ್ಯವನ್ನು ಹಂಚಿಕೊಂಡಾಗ.
- Change Unidirectional Association to Bidirectional: ಕೇವಲ ಒಂದು-ಮಾರ್ಗದ ಲಿಂಕ್ ಇರುವಲ್ಲಿ ಎರಡು ಕ್ಲಾಸ್‌ಗಳ ನಡುವೆ ದ್ವಿಮುಖ ಲಿಂಕ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
- Change Bidirectional Association to Unidirectional: ಎರಡು-ಮಾರ್ಗದ ಸಂಬಂಧವನ್ನು ಒಂದು-ಮಾರ್ಗವಾಗಿ ಮಾಡುವ ಮೂಲಕ ಸಂಘಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.
- Replace Magic Number with Symbolic Constant: ಇದು ಅಕ್ಷರಶಃ ಮೌಲ್ಯಗಳನ್ನು ಹೆಸರಿಸಲಾದ ಕಾನ್ಸ್‌ಟಂಟ್‌ಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
- Encapsulate Field: ಫೀಲ್ಡ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಗೆಟ್ಟರ್ ಮತ್ತು ಸೆಟ್ಟರ್ ಮೆಥಡ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
- Encapsulate Collection: ಕಲೆಕ್ಷನ್‌ನಲ್ಲಿನ ಎಲ್ಲಾ ಬದಲಾವಣೆಗಳು ಮಾಲೀಕ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಎಚ್ಚರಿಕೆಯಿಂದ ನಿಯಂತ್ರಿತ ಮೆಥಡ್‌ಗಳ ಮೂಲಕ ನಡೆಯುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
- Replace Record with Data Class: ರೆಕಾರ್ಡ್‌ನ ರಚನೆ ಮತ್ತು ಅಕ್ಸೆಸರ್ ಮೆಥಡ್‌ಗಳಿಗೆ ಹೊಂದುವ ಫೀಲ್ಡ್‌ಗಳೊಂದಿಗೆ ಹೊಸ ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
- Replace Type Code with Class: ಟೈಪ್ ಕೋಡ್ ಸೀಮಿತ, ತಿಳಿದಿರುವ ಸಂಭವನೀಯ ಮೌಲ್ಯಗಳ ಗುಂಪನ್ನು ಹೊಂದಿರುವಾಗ ಹೊಸ ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸಿ.
- Replace Type Code with Subclasses: ಟೈಪ್ ಕೋಡ್ ಮೌಲ್ಯವು ಕ್ಲಾಸ್‌ನ ನಡವಳಿಕೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಿದಾಗ.
- Replace Type Code with State/Strategy: ಟೈಪ್ ಕೋಡ್ ಮೌಲ್ಯವು ಕ್ಲಾಸ್‌ನ ನಡವಳಿಕೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಿದಾಗ, ಆದರೆ ಸಬ್‌ಕ್ಲಾಸಿಂಗ್ ಸೂಕ್ತವಲ್ಲದಿದ್ದಾಗ.
- Replace Subclass with Fields: ಸಬ್‌ಕ್ಲಾಸ್ ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಸಬ್‌ಕ್ಲಾಸ್‌ನ ವಿಶಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಫೀಲ್ಡ್‌ಗಳನ್ನು ಸೂಪರ್‌ಕ್ಲಾಸ್‌ಗೆ ಸೇರಿಸುತ್ತದೆ.
ಷರತ್ತುಬದ್ಧ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಸರಳಗೊಳಿಸುವುದು (Simplifying Conditional Expressions)
ಷರತ್ತುಬದ್ಧ ತರ್ಕವು ತ್ವರಿತವಾಗಿ ಜಟಿಲವಾಗಬಹುದು. ಈ ತಂತ್ರಗಳು ಸ್ಪಷ್ಟಪಡಿಸಲು ಮತ್ತು ಸರಳಗೊಳಿಸಲು ಗುರಿಯನ್ನು ಹೊಂದಿವೆ.
- Decompose Conditional: ಇದು ಸಂಕೀರ್ಣ ಷರತ್ತುಬದ್ಧ ಹೇಳಿಕೆಯನ್ನು ಚಿಕ್ಕದಾದ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ತುಣುಕುಗಳಾಗಿ ವಿಭಜಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Consolidate Conditional Expression: ಇದು ಅನೇಕ ಷರತ್ತುಬದ್ಧ ಹೇಳಿಕೆಗಳನ್ನು ಒಂದೇ, ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತ ಹೇಳಿಕೆಗೆ ಸಂಯೋಜಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Consolidate Duplicate Conditional Fragments: ಇದು ಷರತ್ತುಬದ್ಧ ಹೇಳಿಕೆಯ ಅನೇಕ ಶಾಖೆಗಳಲ್ಲಿ ನಕಲಿ ಮಾಡಲಾದ ಕೋಡ್ ಅನ್ನು ಷರತ್ತಿನ ಹೊರಗೆ ಸರಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- Remove Control Flag: ತರ್ಕದ ಹರಿವನ್ನು ನಿಯಂತ್ರಿಸಲು ಬಳಸುವ ಬೂಲಿಯನ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಿ.
- Replace Nested Conditional with Guard Clauses: ಎಲ್ಲಾ ವಿಶೇಷ ಪ್ರಕರಣಗಳನ್ನು ಮೇಲ್ಭಾಗದಲ್ಲಿ ಇರಿಸುವ ಮೂಲಕ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ನಿಜವಾಗಿದ್ದರೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಲ್ಲಿಸುವ ಮೂಲಕ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲಂತೆ ಮಾಡುತ್ತದೆ.
- Replace Conditional with Polymorphism: ಇದು ಷರತ್ತುಬದ್ಧ ತರ್ಕವನ್ನು ಪಾಲಿಮಾರ್ಫಿಸಂನೊಂದಿಗೆ ಬದಲಾಯಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ವಿಭಿನ್ನ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ವಿಭಿನ್ನ ಪ್ರಕರಣಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
- Introduce Null Object: ಶೂನ್ಯ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುವ ಬದಲು, ಡೀಫಾಲ್ಟ್ ನಡವಳಿಕೆಯನ್ನು ಒದಗಿಸುವ ಡೀಫಾಲ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಿ.
- Introduce Assertion: ನಿರೀಕ್ಷೆಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಪರೀಕ್ಷೆಯನ್ನು ರಚಿಸುವ ಮೂಲಕ ನಿರೀಕ್ಷೆಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ದಾಖಲಿಸಿ.
ಮೆಥಡ್ ಕರೆಗಳನ್ನು ಸರಳಗೊಳಿಸುವುದು (Simplifying Method Calls)
- Rename Method: ಇದು ಸ್ಪಷ್ಟವಾಗಿ ತೋರುತ್ತದೆ, ಆದರೆ ಕೋಡ್ ಅನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಲು ನಂಬಲಾಗದಷ್ಟು ಸಹಾಯಕವಾಗಿದೆ.
- Add Parameter: ಮೆಥಡ್ ಸಿಗ್ನೇಚರ್‌ಗೆ ಮಾಹಿತಿಯನ್ನು ಸೇರಿಸುವುದರಿಂದ ಮೆಥಡ್ ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದಂತಾಗುತ್ತದೆ.
- Remove Parameter: ಪ್ಯಾರಾಮೀಟರ್ ಬಳಸದಿದ್ದರೆ, ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಸರಳಗೊಳಿಸಲು ಅದನ್ನು ತೊಡೆದುಹಾಕಿ.
- Separate Query from Modifier: ಒಂದು ಮೆಥಡ್ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಿದರೆ ಮತ್ತು ಹಿಂತಿರುಗಿಸಿದರೆ, ಅದನ್ನು ಎರಡು ವಿಭಿನ್ನ ಮೆಥಡ್‌ಗಳಾಗಿ ಪ್ರತ್ಯೇಕಿಸಿ.
- Parameterize Method: ಒಂದೇ ರೀತಿಯ ಮೆಥಡ್‌ಗಳನ್ನು ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸುವ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಒಂದೇ ಮೆಥಡ್‌ಗೆ ಕ್ರೋಢೀಕರಿಸಲು ಇದನ್ನು ಬಳಸಿ.
- Replace Parameter with Explicit Methods: ಪ್ಯಾರಾಮೀಟರೈಸ್‌ನ ವಿರುದ್ಧ ಮಾಡಿ - ಒಂದೇ ಮೆಥಡ್ ಅನ್ನು ಪ್ಯಾರಾಮೀಟರ್‌ನ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಅನೇಕ ಮೆಥಡ್‌ಗಳಾಗಿ ವಿಭಜಿಸಿ.
- Preserve Whole Object: ಮೆಥಡ್‌ಗೆ ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಐಟಂಗಳನ್ನು ರವಾನಿಸುವ ಬದಲು, ಸಂಪೂರ್ಣ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರವಾನಿಸಿ ಇದರಿಂದ ಮೆಥಡ್ ಅದರ ಎಲ್ಲಾ ಡೇಟಾಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ.
- Replace Parameter with Method: ಒಂದು ಮೆಥಡ್ ಅನ್ನು ಯಾವಾಗಲೂ ಫೀಲ್ಡ್‌ನಿಂದ ಪಡೆದ ಅದೇ ಮೌಲ್ಯದೊಂದಿಗೆ ಕರೆಯಿಸಿದರೆ, ಮೆಥಡ್‌ನೊಳಗೆ ಪ್ಯಾರಾಮೀಟರ್ ಮೌಲ್ಯವನ್ನು ಪಡೆಯುವುದನ್ನು ಪರಿಗಣಿಸಿ.
- Introduce Parameter Object: ಹಲವಾರು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಸ್ವಾಭಾವಿಕವಾಗಿ ಒಟ್ಟಿಗೆ ಸೇರಿದಾಗ ಅವುಗಳನ್ನು ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಗುಂಪು ಮಾಡಿ.
- Remove Setting Method: ಒಂದು ಫೀಲ್ಡ್ ಅನ್ನು ಕೇವಲ ಇನಿಶಿಯಲೈಸ್ ಮಾಡಬೇಕಾಗಿದ್ದರೆ, ಆದರೆ ನಿರ್ಮಾಣದ ನಂತರ ಮಾರ್ಪಡಿಸಬಾರದು ಎಂದಾದರೆ ಸೆಟ್ಟರ್‌ಗಳನ್ನು ತಪ್ಪಿಸಿ.
- Hide Method: ಒಂದು ಮೆಥಡ್ ಅನ್ನು ಒಂದೇ ಕ್ಲಾಸ್‌ನೊಳಗೆ ಮಾತ್ರ ಬಳಸಿದರೆ ಅದರ ಗೋಚರತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಿ.
- Replace Constructor with Factory Method: ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ವಿವರಣಾತ್ಮಕ ಪರ್ಯಾಯ.
- Replace Exception with Test: ವಿನಾಯಿತಿಗಳನ್ನು ಫ್ಲೋ ಕಂಟ್ರೋಲ್ ಆಗಿ ಬಳಸುತ್ತಿದ್ದರೆ, ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಅವುಗಳನ್ನು ಷರತ್ತುಬದ್ಧ ತರ್ಕದೊಂದಿಗೆ ಬದಲಾಯಿಸಿ.
ಸಾಮಾನ್ಯೀಕರಣದೊಂದಿಗೆ ವ್ಯವಹರಿಸುವುದು (Dealing with Generalization)
- Pull Up Field: ಒಂದು ಫೀಲ್ಡ್ ಅನ್ನು ಸಬ್‌ಕ್ಲಾಸ್‌ನಿಂದ ಅದರ ಸೂಪರ್‌ಕ್ಲಾಸ್‌ಗೆ ಸರಿಸಿ.
- Pull Up Method: ಒಂದು ಮೆಥಡ್ ಅನ್ನು ಸಬ್‌ಕ್ಲಾಸ್‌ನಿಂದ ಅದರ ಸೂಪರ್‌ಕ್ಲಾಸ್‌ಗೆ ಸರಿಸಿ.
- Pull Up Constructor Body: ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಬಾಡಿಯನ್ನು ಸಬ್‌ಕ್ಲಾಸ್‌ನಿಂದ ಅದರ ಸೂಪರ್‌ಕ್ಲಾಸ್‌ಗೆ ಸರಿಸಿ.
- Push Down Method: ಒಂದು ಮೆಥಡ್ ಅನ್ನು ಸೂಪರ್‌ಕ್ಲಾಸ್‌ನಿಂದ ಅದರ ಸಬ್‌ಕ್ಲಾಸ್‌ಗಳಿಗೆ ಸರಿಸಿ.
- Push Down Field: ಒಂದು ಫೀಲ್ಡ್ ಅನ್ನು ಸೂಪರ್‌ಕ್ಲಾಸ್‌ನಿಂದ ಅದರ ಸಬ್‌ಕ್ಲಾಸ್‌ಗಳಿಗೆ ಸರಿಸಿ.
- Extract Interface: ಒಂದು ಕ್ಲಾಸ್‌ನ ಪಬ್ಲಿಕ್ ಮೆಥಡ್‌ಗಳಿಂದ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
- Extract Superclass: ಎರಡು ಕ್ಲಾಸ್‌ಗಳಿಂದ ಸಾಮಾನ್ಯ ಕಾರ್ಯವನ್ನು ಹೊಸ ಸೂಪರ್‌ಕ್ಲಾಸ್‌ಗೆ ಸರಿಸಿ.
- Collapse Hierarchy: ಸೂಪರ್‌ಕ್ಲಾಸ್ ಮತ್ತು ಸಬ್‌ಕ್ಲಾಸ್ ಅನ್ನು ಒಂದೇ ಕ್ಲಾಸ್‌ಗೆ ಸಂಯೋಜಿಸಿ.
- Form Template Method: ಸೂಪರ್‌ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಟೆಂಪ್ಲೇಟ್ ಮೆಥಡ್ ಅನ್ನು ರಚಿಸಿ ಅದು ಅಲ್ಗಾರಿದಮ್‌ನ ಹಂತಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಸಬ್‌ಕ್ಲಾಸ್‌ಗಳು ನಿರ್ದಿಷ್ಟ ಹಂತಗಳನ್ನು ಓವರ್‌ರೈಡ್ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
- Replace Inheritance with Delegation: ಕಾರ್ಯವನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುವ ಬದಲು, ಅದನ್ನು ಉಲ್ಲೇಖಿಸುವ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಫೀಲ್ಡ್ ಅನ್ನು ರಚಿಸಿ.
- Replace Delegation with Inheritance: ಡೆಲಿಗೇಶನ್ ತುಂಬಾ ಸಂಕೀರ್ಣವಾದಾಗ, ಇನ್ಹೆರಿಟೆನ್ಸ್‌ಗೆ ಬದಲಿಸಿ.
ಇವುಗಳು ಲಭ್ಯವಿರುವ ಅನೇಕ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ತಂತ್ರಗಳಲ್ಲಿ ಕೆಲವು ಉದಾಹರಣೆಗಳು ಮಾತ್ರ. ಯಾವ ತಂತ್ರವನ್ನು ಬಳಸಬೇಕೆಂಬ ಆಯ್ಕೆಯು ನಿರ್ದಿಷ್ಟ ಕೋಡ್ ಸ್ಮೆಲ್ ಮತ್ತು ಅಪೇಕ್ಷಿತ ಫಲಿತಾಂಶವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.
ಉದಾಹರಣೆ: ಜಾಗತಿಕ ಬ್ಯಾಂಕ್ ಬಳಸುವ ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿನ ದೊಡ್ಡ ಮೆಥಡ್ ಒಂದು ಬಡ್ಡಿ ದರಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. ಸಣ್ಣ, ಹೆಚ್ಚು ಕೇಂದ್ರೀಕೃತ ಮೆಥಡ್‌ಗಳನ್ನು ರಚಿಸಲು Extract Method ಅನ್ನು ಅನ್ವಯಿಸುವುದರಿಂದ ಓದುವಿಕೆ ಸುಧಾರಿಸುತ್ತದೆ ಮತ್ತು ಮೆಥಡ್‌ನ ಇತರ ಭಾಗಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರದೆ ಬಡ್ಡಿ ದರದ ಲೆಕ್ಕಾಚಾರದ ತರ್ಕವನ್ನು ನವೀಕರಿಸಲು ಸುಲಭವಾಗುತ್ತದೆ.
ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಪ್ರಕ್ರಿಯೆ
ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ಯಶಸ್ಸಿನ ಸಾಧ್ಯತೆಗಳನ್ನು ಹೆಚ್ಚಿಸಲು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅನ್ನು ವ್ಯವಸ್ಥಿತವಾಗಿ ಸಮೀಪಿಸಬೇಕು. ಇಲ್ಲಿ ಶಿಫಾರಸು ಮಾಡಲಾದ ಪ್ರಕ್ರಿಯೆ ಇದೆ:
- ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅಭ್ಯರ್ಥಿಗಳನ್ನು ಗುರುತಿಸಿ: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ನಿಂದ ಹೆಚ್ಚು ಪ್ರಯೋಜನ ಪಡೆಯುವ ಕೋಡ್‌ನ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು ಹಿಂದೆ ಹೇಳಿದ ಮಾನದಂಡಗಳನ್ನು ಬಳಸಿ.
- ಟೆಸ್ಟ್‌ಗಳನ್ನು ರಚಿಸಿ: ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವ ಮೊದಲು, ಕೋಡ್‌ನ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನಡವಳಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಸ್ವಯಂಚಾಲಿತ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯಿರಿ. ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ರಿಗ್ರೆಷನ್‌ಗಳನ್ನು ಪರಿಚಯಿಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. JUnit (Java), pytest (Python), ಅಥವಾ Jest (JavaScript) ನಂತಹ ಉಪಕರಣಗಳನ್ನು ಯೂನಿಟ್ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯಲು ಬಳಸಬಹುದು.
- ಹಂತ ಹಂತವಾಗಿ ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಿ: ಸಣ್ಣ, ಹಂತ ಹಂತದ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿ ಮತ್ತು ಪ್ರತಿ ಬದಲಾವಣೆಯ ನಂತರ ಟೆಸ್ಟ್‌ಗಳನ್ನು ರನ್ ಮಾಡಿ. ಇದು ಪರಿಚಯಿಸಲಾದ ಯಾವುದೇ ದೋಷಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಸರಿಪಡಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
- ಆಗಾಗ್ಗೆ ಕಮಿಟ್ ಮಾಡಿ: ನಿಮ್ಮ ಬದಲಾವಣೆಗಳನ್ನು ಆವೃತ್ತಿ ನಿಯಂತ್ರಣಕ್ಕೆ (version control) ಆಗಾಗ್ಗೆ ಕಮಿಟ್ ಮಾಡಿ. ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ ಹಿಂದಿನ ಆವೃತ್ತಿಗೆ ಸುಲಭವಾಗಿ ಹಿಂತಿರುಗಲು ಇದು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
- ಕೋಡ್ ವಿಮರ್ಶೆ ಮಾಡಿ: ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಇನ್ನೊಬ್ಬ ಡೆವಲಪರ್‌ನಿಂದ ವಿಮರ್ಶೆ ಮಾಡಿಸಿ. ಇದು ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಸರಿಯಾಗಿ ಮಾಡಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
- ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ನಂತರ, ಬದಲಾವಣೆಗಳು ಯಾವುದೇ ಕಾರ್ಯಕ್ಷಮತೆಯ ರಿಗ್ರೆಷನ್‌ಗಳನ್ನು ಪರಿಚಯಿಸಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಿಸ್ಟಮ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ.
ಉದಾಹರಣೆ: ಜಾಗತಿಕ ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡುತ್ತಿರುವ ತಂಡವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕಾರ್ಯಕ್ಕಾಗಿ ಯೂನಿಟ್ ಟೆಸ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು `pytest` ಅನ್ನು ಬಳಸುತ್ತದೆ. ನಂತರ ಅವರು ಕಳವಳಗಳನ್ನು ಬೇರ್ಪಡಿಸಲು ಮತ್ತು ಮಾಡ್ಯೂಲ್‌ನ ರಚನೆಯನ್ನು ಸುಧಾರಿಸಲು Extract Class ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅನ್ನು ಅನ್ವಯಿಸುತ್ತಾರೆ. ಪ್ರತಿ ಸಣ್ಣ ಬದಲಾವಣೆಯ ನಂತರ, ಕಾರ್ಯವು ಬದಲಾಗದೆ ಉಳಿದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅವರು ಟೆಸ್ಟ್‌ಗಳನ್ನು ರನ್ ಮಾಡುತ್ತಾರೆ.
ಲೆಗಸಿ ಕೋಡ್‌ಗೆ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಪರಿಚಯಿಸುವ ತಂತ್ರಗಳು
ಮೈಕೆಲ್ ಫೆದರ್ಸ್ ಸೂಕ್ತವಾಗಿ ಹೇಳಿದಂತೆ, ಲೆಗಸಿ ಕೋಡ್ ಎಂದರೆ ಟೆಸ್ಟ್‌ಗಳಿಲ್ಲದ ಕೋಡ್. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್‌ಬೇಸ್‌ಗಳಿಗೆ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಪರಿಚಯಿಸುವುದು ಒಂದು ದೊಡ್ಡ ಕಾರ್ಯವೆಂದು ಅನಿಸಬಹುದು, ಆದರೆ ಸುರಕ್ಷಿತ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ಗೆ ಇದು ಅತ್ಯಗತ್ಯ. ಈ ಕಾರ್ಯವನ್ನು ಸಮೀಪಿಸಲು ಹಲವಾರು ತಂತ್ರಗಳು ಇಲ್ಲಿವೆ:
ಕ್ಯಾರೆಕ್ಟರೈಸೇಶನ್ ಟೆಸ್ಟ್‌ಗಳು (ಗೋಲ್ಡನ್ ಮಾಸ್ಟರ್ ಟೆಸ್ಟ್‌ಗಳು)
ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟಕರವಾದ ಕೋಡ್‌ನೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತಿರುವಾಗ, ನೀವು ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಅದರ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನಡವಳಿಕೆಯನ್ನು ಸೆರೆಹಿಡಿಯಲು ಕ್ಯಾರೆಕ್ಟರೈಸೇಶನ್ ಟೆಸ್ಟ್‌ಗಳು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ. ನಿರ್ದಿಷ್ಟ ಇನ್‌ಪುಟ್‌ಗಳ ಗುಂಪಿಗೆ ಕೋಡ್‌ನ ಪ್ರಸ್ತುತ ಔಟ್‌ಪುಟ್ ಅನ್ನು ದೃಢೀಕರಿಸುವ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯುವುದು ಇದರ ಕಲ್ಪನೆ. ಈ ಟೆಸ್ಟ್‌ಗಳು ಸರಿಯಾಗಿರುವುದನ್ನು ಪರಿಶೀಲಿಸುವುದಿಲ್ಲ; ಅವು ಕೇವಲ ಕೋಡ್ *ಪ್ರಸ್ತುತ* ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ದಾಖಲಿಸುತ್ತವೆ.
ಹಂತಗಳು:
- ನೀವು ಗುಣಲಕ್ಷಣವನ್ನು ನೀಡಲು ಬಯಸುವ ಕೋಡ್‌ನ ಘಟಕವನ್ನು ಗುರುತಿಸಿ (ಉದಾಹರಣೆಗೆ, ಫಂಕ್ಷನ್ ಅಥವಾ ಮೆಥಡ್).
- ಸಾಮಾನ್ಯ ಮತ್ತು ಎಡ್ಜ್-ಕೇಸ್ ಸನ್ನಿವೇಶಗಳ ಶ್ರೇಣಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಇನ್‌ಪುಟ್ ಮೌಲ್ಯಗಳ ಗುಂಪನ್ನು ರಚಿಸಿ.
- ಆ ಇನ್‌ಪುಟ್‌ಗಳೊಂದಿಗೆ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡಿ ಮತ್ತು ಫಲಿತಾಂಶದ ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಸೆರೆಹಿಡಿಯಿರಿ.
- ಆ ಇನ್‌ಪುಟ್‌ಗಳಿಗೆ ಕೋಡ್ ಅದೇ ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಎಂದು ದೃಢೀಕರಿಸುವ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯಿರಿ.
ಎಚ್ಚರಿಕೆ: ಆಧಾರವಾಗಿರುವ ತರ್ಕವು ಸಂಕೀರ್ಣವಾಗಿದ್ದರೆ ಅಥವಾ ಡೇಟಾ-ಅವಲಂಬಿತವಾಗಿದ್ದರೆ ಕ್ಯಾರೆಕ್ಟರೈಸೇಶನ್ ಟೆಸ್ಟ್‌ಗಳು ದುರ್ಬಲವಾಗಿರಬಹುದು. ನೀವು ನಂತರ ಕೋಡ್‌ನ ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸಬೇಕಾದರೆ ಅವುಗಳನ್ನು ನವೀಕರಿಸಲು ಸಿದ್ಧರಾಗಿರಿ.
Sprout Method ಮತ್ತು Sprout Class
ಮೈಕೆಲ್ ಫೆದರ್ಸ್ ವಿವರಿಸಿದ ಈ ತಂತ್ರಗಳು, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್ ಅನ್ನು ಮುರಿಯುವ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುವಾಗ ಲೆಗಸಿ ಸಿಸ್ಟಮ್‌ಗೆ ಹೊಸ ಕಾರ್ಯವನ್ನು ಪರಿಚಯಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿವೆ.
Sprout Method: ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮೆಥಡ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುವ ಅಗತ್ಯವಿರುವ ಹೊಸ ಫೀಚರ್ ಅನ್ನು ನೀವು ಸೇರಿಸಬೇಕಾದಾಗ, ಹೊಸ ತರ್ಕವನ್ನು ಒಳಗೊಂಡಿರುವ ಹೊಸ ಮೆಥಡ್ ಅನ್ನು ರಚಿಸಿ. ನಂತರ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮೆಥಡ್‌ನಿಂದ ಈ ಹೊಸ ಮೆಥಡ್ ಅನ್ನು ಕರೆ ಮಾಡಿ. ಇದು ಹೊಸ ಕೋಡ್ ಅನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಮತ್ತು ಅದನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಪರೀಕ್ಷಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
Sprout Class: Sprout Method ಗೆ ಹೋಲುತ್ತದೆ, ಆದರೆ ಕ್ಲಾಸ್‌ಗಳಿಗಾಗಿ. ಹೊಸ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಹೊಸ ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸಿ, ಮತ್ತು ನಂತರ ಅದನ್ನು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸಿಸ್ಟಮ್‌ಗೆ ಸಂಯೋಜಿಸಿ.
ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್ (Sandboxing)
ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್ ಎಂದರೆ ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ಸಿಸ್ಟಮ್‌ನ ಉಳಿದ ಭಾಗದಿಂದ ಪ್ರತ್ಯೇಕಿಸುವುದು, ನಿಯಂತ್ರಿತ ಪರಿಸರದಲ್ಲಿ ಅದನ್ನು ಪರೀಕ್ಷಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಅವಲಂಬನೆಗಳಿಗಾಗಿ ಮಾಕ್‌ಗಳು ಅಥವಾ ಸ್ಟಬ್‌ಗಳನ್ನು ರಚಿಸುವ ಮೂಲಕ ಅಥವಾ ವರ್ಚುವಲ್ ಯಂತ್ರದಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಬಹುದು.
ಮಿಕಾಡೋ ಮೆಥಡ್ (The Mikado Method)
ಮಿಕಾಡೋ ಮೆಥಡ್ ಸಂಕೀರ್ಣ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಕಾರ್ಯಗಳನ್ನು ನಿಭಾಯಿಸಲು ದೃಶ್ಯ ಸಮಸ್ಯ-ಪರಿಹಾರ ವಿಧಾನವಾಗಿದೆ. ಇದು ಕೋಡ್‌ನ ವಿಭಿನ್ನ ಭಾಗಗಳ ನಡುವಿನ ಅವಲಂಬನೆಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ರೇಖಾಚಿತ್ರವನ್ನು ರಚಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಮತ್ತು ನಂತರ ಸಿಸ್ಟಮ್‌ನ ಇತರ ಭಾಗಗಳ ಮೇಲೆ ಪರಿಣಾಮವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ರೀತಿಯಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡುತ್ತದೆ. ಮೂಲ ತತ್ವವೆಂದರೆ ಬದಲಾವಣೆಯನ್ನು "ಪ್ರಯತ್ನಿಸುವುದು" ಮತ್ತು ಏನು ಮುರಿಯುತ್ತದೆ ಎಂದು ನೋಡುವುದು. ಅದು ಮುರಿದರೆ, ಕೊನೆಯ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದ ಸ್ಥಿತಿಗೆ ಹಿಂತಿರುಗಿ ಮತ್ತು ಸಮಸ್ಯೆಯನ್ನು ದಾಖಲಿಸಿ. ನಂತರ ಮೂಲ ಬದಲಾವಣೆಯನ್ನು ಮರು-ಪ್ರಯತ್ನಿಸುವ ಮೊದಲು ಆ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿ.
ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ಗಾಗಿ ಪರಿಕರಗಳು
ಹಲವಾರು ಪರಿಕರಗಳು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ಗೆ ಸಹಾಯ ಮಾಡಬಹುದು, ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳ ಬಗ್ಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡಬಹುದು. ಈ ಪರಿಕರಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಇಂಟಿಗ್ರೇಟೆಡ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಎನ್ವಿರಾನ್‌ಮೆಂಟ್‌ಗಳಲ್ಲಿ (IDEs) ಸಂಯೋಜಿಸಲ್ಪಟ್ಟಿರುತ್ತವೆ:
- IDEs (ಉದಾ., IntelliJ IDEA, Eclipse, Visual Studio): IDE ಗಳು ಅಂತರ್ನಿರ್ಮಿತ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಪರಿಕರಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಅದು ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಮರುಹೆಸರಿಸುವುದು, ಮೆಥಡ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು ಮತ್ತು ಕ್ಲಾಸ್‌ಗಳನ್ನು ಸರಿಸುವಂತಹ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸಬಹುದು.
- ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಪರಿಕರಗಳು (ಉದಾ., SonarQube, Checkstyle, PMD): ಈ ಪರಿಕರಗಳು ಕೋಡ್ ಸ್ಮೆಲ್‌ಗಳು, ಸಂಭಾವ್ಯ ಬಗ್‌ಗಳು ಮತ್ತು ಭದ್ರತಾ ದೋಷಗಳಿಗಾಗಿ ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತವೆ. ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ನಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯುವ ಕೋಡ್‌ನ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು ಅವು ಸಹಾಯ ಮಾಡುತ್ತವೆ.
- ಕೋಡ್ ಕವರೇಜ್ ಪರಿಕರಗಳು (ಉದಾ., JaCoCo, Cobertura): ಈ ಪರಿಕರಗಳು ಟೆಸ್ಟ್‌ಗಳಿಂದ ಆವರಿಸಿರುವ ಕೋಡ್‌ನ ಶೇಕಡಾವಾರು ಪ್ರಮಾಣವನ್ನು ಅಳೆಯುತ್ತವೆ. ಸಮರ್ಪಕವಾಗಿ ಪರೀಕ್ಷಿಸದ ಕೋಡ್‌ನ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು ಅವು ಸಹಾಯ ಮಾಡುತ್ತವೆ.
- ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಬ್ರೌಸರ್‌ಗಳು (ಉದಾ., Smalltalk Refactoring Browser): ದೊಡ್ಡ ಪುನರ್ರಚನಾ ಚಟುವಟಿಕೆಗಳಲ್ಲಿ ಸಹಾಯ ಮಾಡುವ ವಿಶೇಷ ಪರಿಕರಗಳು.
ಉದಾಹರಣೆ: ಜಾಗತಿಕ ವಿಮಾ ಕಂಪನಿಗಾಗಿ C# ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿರುವ ಅಭಿವೃದ್ಧಿ ತಂಡವು ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರುಹೆಸರಿಸಲು ಮತ್ತು ಮೆಥಡ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಲು ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋದ ಅಂತರ್ನಿರ್ಮಿತ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಪರಿಕರಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಅವರು ಕೋಡ್ ಸ್ಮೆಲ್‌ಗಳು ಮತ್ತು ಸಂಭಾವ್ಯ ದೋಷಗಳನ್ನು ಗುರುತಿಸಲು ಸೋನಾರ್‌ಕ್ಯೂಬ್ ಅನ್ನು ಸಹ ಬಳಸುತ್ತಾರೆ.
ಸವಾಲುಗಳು ಮತ್ತು ಅಪಾಯಗಳು
ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡುವುದು ಅದರ ಸವಾಲುಗಳು ಮತ್ತು ಅಪಾಯಗಳಿಲ್ಲದೆ ಇಲ್ಲ:
- ರಿಗ್ರೆಷನ್‌ಗಳನ್ನು ಪರಿಚಯಿಸುವುದು: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಬಗ್‌ಗಳನ್ನು ಪರಿಚಯಿಸುವುದು ಅತಿದೊಡ್ಡ ಅಪಾಯವಾಗಿದೆ. ಸಮಗ್ರ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯುವ ಮೂಲಕ ಮತ್ತು ಹಂತ ಹಂತವಾಗಿ ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡುವ ಮೂಲಕ ಇದನ್ನು ತಗ್ಗಿಸಬಹುದು.
- ಡೊಮೇನ್ ಜ್ಞಾನದ ಕೊರತೆ: ಮೂಲ ಡೆವಲಪರ್‌ಗಳು ಹೊರಟುಹೋದರೆ, ಕೋಡ್ ಮತ್ತು ಅದರ ಉದ್ದೇಶವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕಷ್ಟಕರವಾಗಿರುತ್ತದೆ. ಇದು ತಪ್ಪಾದ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ನಿರ್ಧಾರಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
- ಬಿಗಿಯಾದ ಕಪ್ಲಿಂಗ್: ಬಿಗಿಯಾಗಿ ಕಪಲ್ ಆದ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡುವುದು ಹೆಚ್ಚು ಕಷ್ಟಕರ, ಏಕೆಂದರೆ ಕೋಡ್‌ನ ಒಂದು ಭಾಗದಲ್ಲಿನ ಬದಲಾವಣೆಗಳು ಕೋಡ್‌ನ ಇತರ ಭಾಗಗಳ ಮೇಲೆ ಉದ್ದೇಶಪೂರ್ವಕವಲ್ಲದ ಪರಿಣಾಮಗಳನ್ನು ಬೀರಬಹುದು.
- ಸಮಯದ ನಿರ್ಬಂಧಗಳು: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಮತ್ತು ಹೊಸ ಫೀಚರ್‌ಗಳನ್ನು ತಲುಪಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿದ ಪಾಲುದಾರರಿಗೆ ಹೂಡಿಕೆಯನ್ನು ಸಮರ್ಥಿಸಿಕೊಳ್ಳುವುದು ಕಷ್ಟಕರವಾಗಿರುತ್ತದೆ.
- ಬದಲಾವಣೆಗೆ ಪ್ರತಿರೋಧ: ಕೆಲವು ಡೆವಲಪರ್‌ಗಳು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ಗೆ ನಿರೋಧಕವಾಗಿರಬಹುದು, ವಿಶೇಷವಾಗಿ ಅವರು ಒಳಗೊಂಡಿರುವ ತಂತ್ರಗಳೊಂದಿಗೆ ಪರಿಚಿತರಲ್ಲದಿದ್ದರೆ.
ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡುವುದಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಸವಾಲುಗಳು ಮತ್ತು ಅಪಾಯಗಳನ್ನು ತಗ್ಗಿಸಲು, ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸಿ:
- ಒಪ್ಪಿಗೆ ಪಡೆಯಿರಿ: ಪಾಲುದಾರರು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ನ ಪ್ರಯೋಜನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದಾರೆ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಸಮಯ ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹೂಡಿಕೆ ಮಾಡಲು ಸಿದ್ಧರಿದ್ದಾರೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
- ಸಣ್ಣದಾಗಿ ಪ್ರಾರಂಭಿಸಿ: ಸಣ್ಣ, ಪ್ರತ್ಯೇಕವಾದ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ. ಇದು ವಿಶ್ವಾಸವನ್ನು ಮೂಡಿಸಲು ಮತ್ತು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
- ಹಂತ ಹಂತವಾಗಿ ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಿ: ಸಣ್ಣ, ಹಂತ ಹಂತದ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿ ಮತ್ತು ಆಗಾಗ್ಗೆ ಪರೀಕ್ಷಿಸಿ. ಇದು ಪರಿಚಯಿಸಲಾದ ಯಾವುದೇ ದೋಷಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಸರಿಪಡಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
- ಟೆಸ್ಟ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಿ: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಮೊದಲು ಮತ್ತು ನಂತರ ಕೋಡ್‌ನ ನಡವಳಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಸಮಗ್ರ ಸ್ವಯಂಚಾಲಿತ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯಿರಿ.
- ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಪರಿಕರಗಳನ್ನು ಬಳಸಿ: ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳ ಬಗ್ಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡಲು ನಿಮ್ಮ IDE ಅಥವಾ ಇತರ ಪರಿಕರಗಳಲ್ಲಿ ಲಭ್ಯವಿರುವ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಪರಿಕರಗಳನ್ನು ಬಳಸಿ.
- ನಿಮ್ಮ ಬದಲಾವಣೆಗಳನ್ನು ದಾಖಲಿಸಿ: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಸಮಯದಲ್ಲಿ ನೀವು ಮಾಡುವ ಬದಲಾವಣೆಗಳನ್ನು ದಾಖಲಿಸಿ. ಇದು ಇತರ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಭವಿಷ್ಯದಲ್ಲಿ ರಿಗ್ರೆಷನ್‌ಗಳನ್ನು ಪರಿಚಯಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
- ನಿರಂತರ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್: ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅನ್ನು ಒಂದು-ಬಾರಿಯ ಘಟನೆಯ ಬದಲು ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯ ನಿರಂತರ ಭಾಗವನ್ನಾಗಿ ಮಾಡಿ. ಇದು ಕೋಡ್‌ಬೇಸ್ ಅನ್ನು ಸ್ವಚ್ಛವಾಗಿ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲಂತೆ ಇರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ತೀರ್ಮಾನ
ಲೆಗಸಿ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡುವುದು ಒಂದು ಸವಾಲಿನ ಆದರೆ ಲಾಭದಾಯಕ ಪ್ರಯತ್ನವಾಗಿದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ವಿವರಿಸಲಾದ ತಂತ್ರಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನೀವು ಆ ಸವಾಲನ್ನು ಪಳಗಿಸಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಲೆಗಸಿ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದಾದ, ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಆಸ್ತಿಗಳಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು. ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅನ್ನು ವ್ಯವಸ್ಥಿತವಾಗಿ ಸಮೀಪಿಸಲು, ಆಗಾಗ್ಗೆ ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿಮ್ಮ ತಂಡದೊಂದಿಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಂವಹನ ನಡೆಸಲು ಮರೆಯದಿರಿ. ಎಚ್ಚರಿಕೆಯ ಯೋಜನೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯೊಂದಿಗೆ, ನಿಮ್ಮ ಲೆಗಸಿ ಕೋಡ್‌ನಲ್ಲಿ ಅಡಗಿರುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀವು ಅನ್ಲಾಕ್ ಮಾಡಬಹುದು ಮತ್ತು ಭವಿಷ್ಯದ ನಾವೀನ್ಯತೆಗೆ ದಾರಿ ಮಾಡಿಕೊಡಬಹುದು.